﻿// -------------------------------------------------------------------------
//    @FileName         :    NFSha256.h
//    @Author           :    Gao.Yi
//    @Date             :   2022-09-18
//    @Email			:    445267987@qq.com
//    @Module           :    NFCore
//
// -------------------------------------------------------------------------

/**
 * @file NFSha256.h
 * @brief SHA-256算法模板实现
 * 
 * 此文件提供了SHA-256算法的现代C++模板实现。支持任意类型的输入迭代器，
 * 可以高效处理各种数据源（内存块、文件流、容器等）。这是一个头文件
 * 模板库，提供了类型安全和高性能的SHA-256哈希计算功能。
 */

#pragma once

// NFSha256:20140213

/**
 * @brief 输入迭代器缓冲区大小配置
 * 
 * 当使用输入迭代器处理大数据时的内部缓冲区大小。
 * 默认为1MB，可以通过预定义此宏来调整。
 */
#ifndef NFSha256_BUFFER_SIZE_FOR_INPUT_ITERATOR
#define NFSha256_BUFFER_SIZE_FOR_INPUT_ITERATOR \
    1048576  //=1024*1024: default is 1MB memory
#endif

#include <algorithm>
#include <cassert>
#include <iterator>
#include <sstream>
#include <vector>
#include <fstream>

/**
 * @brief SHA-256算法实现命名空间
 * 
 * NFSha256命名空间包含了SHA-256算法的完整实现，包括类型定义、
 * 常量、内部函数和主要的计算接口。采用现代C++设计，支持
 * 模板化和泛型编程。
 * 
 * 主要特性：
 * - 模板化设计：支持任意输入迭代器类型
 * - 类型安全：使用强类型避免常见错误
 * - 高性能：优化的算法实现和内存管理
 * - 标准兼容：符合FIPS PUB 180-4标准
 * - 零依赖：除标准库外无外部依赖
 * 
 * 算法特点：
 * - 输出长度：256位（32字节）
 * - 块大小：512位（64字节）
 * - 轮次数：64轮
 * - 安全性：目前仍然安全，推荐使用
 * 
 * 适用场景：
 * - 密码学应用
 * - 数字签名
 * - 数据完整性校验
 * - 区块链和加密货币
 * - 现代安全协议
 * 
 * 使用方法：
 * @code
 * #include "NFSha256.h"
 * 
 * // 字符串哈希
 * std::string data = "Hello World";
 * std::string hash = NFSha256::hash256_hex_string(data);
 * std::cout << "SHA-256: " << hash << std::endl;
 * 
 * // 向量数据哈希
 * std::vector<uint8_t> vec_data = {0x48, 0x65, 0x6c, 0x6c, 0x6f};
 * auto digest = NFSha256::hash256(vec_data.begin(), vec_data.end());
 * 
 * // 文件哈希
 * std::ifstream file("test.txt", std::ios::binary);
 * std::string file_hash = NFSha256::hash256_hex_string(
 *     std::istreambuf_iterator<char>(file),
 *     std::istreambuf_iterator<char>()
 * );
 * @endcode
 * 
 * @note 此实现是线程安全的（无全局状态）
 * @note 支持增量计算和流式处理
 */
namespace NFSha256 {
	/** @brief 32位字类型定义 */
	typedef unsigned long word_t;
	/** @brief 8位字节类型定义 */
	typedef unsigned char byte_t;

	/** @brief SHA-256摘要长度（字节数） */
	static const size_t k_digest_size = 32;

	/**
	 * @brief SHA-256算法内部实现命名空间
	 * 
	 * detail命名空间包含了SHA-256算法的内部实现细节，
	 * 包括位操作函数、常量表和核心计算函数。
	 */
	namespace detail {
		/**
		 * @brief 8位掩码操作
		 * 
		 * @param x 输入值
		 * @return byte_t masked后的8位值
		 */
		inline byte_t mask_8bit(byte_t x) { return x & 0xff; }

		/**
		 * @brief 32位掩码操作
		 * 
		 * @param x 输入值  
		 * @return word_t masked后的32位值
		 */
		inline word_t mask_32bit(word_t x) { return x & 0xffffffff; }

		/**
		 * @brief SHA-256算法的64个轮常数
		 * 
		 * 这些常数是2^32乘以前64个质数的立方根的小数部分。
		 */
		const word_t add_constant[64] = {
			0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
			0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
			0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
			0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
			0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
			0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
			0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
			0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
			0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
			0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
			0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };

		/**
		 * @brief SHA-256初始哈希值
		 * 
		 * 这些值是前8个质数的平方根的小数部分的前32位。
		 */
		const word_t initial_message_digest[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372,
												  0xa54ff53a, 0x510e527f, 0x9b05688c,
												  0x1f83d9ab, 0x5be0cd19 };

		/**
		 * @brief SHA-256的Ch函数
		 * 
		 * @param x 32位字
		 * @param y 32位字  
		 * @param z 32位字
		 * @return word_t Ch(x,y,z) = (x & y) ^ ((~x) & z)
		 */
		inline word_t ch(word_t x, word_t y, word_t z) { return (x & y) ^ ((~x) & z); }

		/**
		 * @brief SHA-256的Maj函数
		 * 
		 * @param x 32位字
		 * @param y 32位字
		 * @param z 32位字  
		 * @return word_t Maj(x,y,z) = (x & y) ^ (x & z) ^ (y & z)
		 */
		inline word_t maj(word_t x, word_t y, word_t z) {
			return (x & y) ^ (x & z) ^ (y & z);
		}

		/**
		 * @brief 循环右移操作
		 * 
		 * @param x 要旋转的32位字
		 * @param n 右移位数（0-31）
		 * @return word_t 旋转后的结果
		 */
		inline word_t rotr(word_t x, std::size_t n) {
			assert(n < 32);
			return mask_32bit((x >> n) | (x << (32 - n)));
		}

		/**
		 * @brief SHA-256的大Sigma0函数
		 * 
		 * @param x 32位字
		 * @return word_t ROTR(x,2) ⊕ ROTR(x,13) ⊕ ROTR(x,22)
		 */
		inline word_t bsig0(word_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); }

		/**
		 * @brief SHA-256的大Sigma1函数
		 * 
		 * @param x 32位字
		 * @return word_t ROTR(x,6) ⊕ ROTR(x,11) ⊕ ROTR(x,25)
		 */
		inline word_t bsig1(word_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); }

		/**
		 * @brief 逻辑右移操作
		 * 
		 * @param x 要移位的32位字
		 * @param n 右移位数（0-31）
		 * @return word_t 移位后的结果
		 */
		inline word_t shr(word_t x, std::size_t n) {
			assert(n < 32);
			return x >> n;
		}

		/**
		 * @brief SHA-256的小sigma0函数
		 * 
		 * @param x 32位字
		 * @return word_t ROTR(x,7) ⊕ ROTR(x,18) ⊕ SHR(x,3)
		 */
		inline word_t ssig0(word_t x) { return rotr(x, 7) ^ rotr(x, 18) ^ shr(x, 3); }

		/**
		 * @brief SHA-256的小sigma1函数
		 * 
		 * @param x 32位字
		 * @return word_t ROTR(x,17) ⊕ ROTR(x,19) ⊕ SHR(x,10)
		 */
		inline word_t ssig1(word_t x) { return rotr(x, 17) ^ rotr(x, 19) ^ shr(x, 10); }

		/**
		 * @brief 处理单个512位消息块
		 * 
		 * 这是SHA-256算法的核心函数，处理单个64字节的消息块。
		 * 
		 * @tparam RaIter1 消息摘要的随机访问迭代器类型
		 * @tparam RaIter2 消息块的随机访问迭代器类型
		 * @param message_digest 指向8个32位字的消息摘要数组
		 * @param first 消息块起始迭代器
		 * @param last 消息块结束迭代器
		 * 
		 * @note 消息块必须恰好是64字节
		 * @note message_digest会被就地更新
		 */
		template <typename RaIter1, typename RaIter2>
		void hash256_block(RaIter1 message_digest, RaIter2 first, RaIter2 last) {
			assert(first + 64 == last);
			static_cast<void>(last);  // for avoiding unused-variable warning
			word_t w[64];
			std::fill(w, w + 64, 0);
			for (std::size_t i = 0; i < 16; ++i) {
				w[i] = (static_cast<word_t>(mask_8bit(*(first + i * 4))) << 24) |
					(static_cast<word_t>(mask_8bit(*(first + i * 4 + 1))) << 16) |
					(static_cast<word_t>(mask_8bit(*(first + i * 4 + 2))) << 8) |
					(static_cast<word_t>(mask_8bit(*(first + i * 4 + 3))));
			}
			for (std::size_t i = 16; i < 64; ++i) {
				w[i] = mask_32bit(ssig1(w[i - 2]) + w[i - 7] + ssig0(w[i - 15]) +
					w[i - 16]);
			}

			word_t a = *message_digest;
			word_t b = *(message_digest + 1);
			word_t c = *(message_digest + 2);
			word_t d = *(message_digest + 3);
			word_t e = *(message_digest + 4);
			word_t f = *(message_digest + 5);
			word_t g = *(message_digest + 6);
			word_t h = *(message_digest + 7);

			for (std::size_t i = 0; i < 64; ++i) {
				word_t temp1 = h + bsig1(e) + ch(e, f, g) + add_constant[i] + w[i];
				word_t temp2 = bsig0(a) + maj(a, b, c);
				h = g;
				g = f;
				f = e;
				e = mask_32bit(d + temp1);
				d = c;
				c = b;
				b = a;
				a = mask_32bit(temp1 + temp2);
			}
			*message_digest += a;
			*(message_digest + 1) += b;
			*(message_digest + 2) += c;
			*(message_digest + 3) += d;
			*(message_digest + 4) += e;
			*(message_digest + 5) += f;
			*(message_digest + 6) += g;
			*(message_digest + 7) += h;
			for (std::size_t i = 0; i < 8; ++i) {
				*(message_digest + i) = mask_32bit(*(message_digest + i));
			}
		}

	}  // namespace detail

	template <typename InIter>
	void output_hex(InIter first, InIter last, std::ostream& os) {
		os.setf(std::ios::hex, std::ios::basefield);
		while (first != last) {
			os.width(2);
			os.fill('0');
			os << static_cast<unsigned int>(*first);
			++first;
		}
		os.setf(std::ios::dec, std::ios::basefield);
	}

	template <typename InIter>
	void bytes_to_hex_string(InIter first, InIter last, std::string& hex_str) {
		std::ostringstream oss;
		output_hex(first, last, oss);
		hex_str.assign(oss.str());
	}

	template <typename InContainer>
	void bytes_to_hex_string(const InContainer& bytes, std::string& hex_str) {
		bytes_to_hex_string(bytes.begin(), bytes.end(), hex_str);
	}

	template <typename InIter>
	std::string bytes_to_hex_string(InIter first, InIter last) {
		std::string hex_str;
		bytes_to_hex_string(first, last, hex_str);
		return hex_str;
	}

	template <typename InContainer>
	std::string bytes_to_hex_string(const InContainer& bytes) {
		std::string hex_str;
		bytes_to_hex_string(bytes, hex_str);
		return hex_str;
	}

	class hash256_one_by_one {
	public:
		hash256_one_by_one() { init(); }

		void init() {
			buffer_.clear();
			std::fill(data_length_digits_, data_length_digits_ + 4, 0);
			std::copy(detail::initial_message_digest,
				detail::initial_message_digest + 8, h_);
		}

		template <typename RaIter>
		void process(RaIter first, RaIter last) {
			add_to_data_length(static_cast<word_t>(std::distance(first, last)));
			std::copy(first, last, std::back_inserter(buffer_));
			std::size_t i = 0;
			for (; i + 64 <= buffer_.size(); i += 64) {
				detail::hash256_block(h_, buffer_.begin() + i,
					buffer_.begin() + i + 64);
			}
			buffer_.erase(buffer_.begin(), buffer_.begin() + i);
		}

		void finish() {
			byte_t temp[64];
			std::fill(temp, temp + 64, 0);
			std::size_t remains = buffer_.size();
			std::copy(buffer_.begin(), buffer_.end(), temp);
			temp[remains] = 0x80;

			if (remains > 55) {
				std::fill(temp + remains + 1, temp + 64, 0);
				detail::hash256_block(h_, temp, temp + 64);
				std::fill(temp, temp + 64 - 4, 0);
			}
			else {
				std::fill(temp + remains + 1, temp + 64 - 4, 0);
			}

			write_data_bit_length(&(temp[56]));
			detail::hash256_block(h_, temp, temp + 64);
		}

		template <typename OutIter>
		void get_hash_bytes(OutIter first, OutIter last) const {
			for (const word_t* iter = h_; iter != h_ + 8; ++iter) {
				for (std::size_t i = 0; i < 4 && first != last; ++i) {
					*(first++) = detail::mask_8bit(
						static_cast<byte_t>((*iter >> (24 - 8 * i))));
				}
			}
		}

	private:
		void add_to_data_length(word_t n) {
			word_t carry = 0;
			data_length_digits_[0] += n;
			for (std::size_t i = 0; i < 4; ++i) {
				data_length_digits_[i] += carry;
				if (data_length_digits_[i] >= 65536u) {
					carry = data_length_digits_[i] >> 16;
					data_length_digits_[i] &= 65535u;
				}
				else {
					break;
				}
			}
		}
		void write_data_bit_length(byte_t* begin) {
			word_t data_bit_length_digits[4];
			std::copy(data_length_digits_, data_length_digits_ + 4,
				data_bit_length_digits);

			// convert byte length to bit length (multiply 8 or shift 3 times left)
			word_t carry = 0;
			for (std::size_t i = 0; i < 4; ++i) {
				word_t before_val = data_bit_length_digits[i];
				data_bit_length_digits[i] <<= 3;
				data_bit_length_digits[i] |= carry;
				data_bit_length_digits[i] &= 65535u;
				carry = (before_val >> (16 - 3)) & 65535u;
			}

			// write data_bit_length
			for (int i = 3; i >= 0; --i) {
				(*begin++) = static_cast<byte_t>(data_bit_length_digits[i] >> 8);
				(*begin++) = static_cast<byte_t>(data_bit_length_digits[i]);
			}
		}
		std::vector<byte_t> buffer_;
		word_t data_length_digits_[4];  // as 64bit integer (16bit x 4 integer)
		word_t h_[8];
	};

	inline void get_hash_hex_string(const hash256_one_by_one& hasher,
		std::string& hex_str) {
		byte_t hash[k_digest_size];
		hasher.get_hash_bytes(hash, hash + k_digest_size);
		return bytes_to_hex_string(hash, hash + k_digest_size, hex_str);
	}

	inline std::string get_hash_hex_string(const hash256_one_by_one& hasher) {
		std::string hex_str;
		get_hash_hex_string(hasher, hex_str);
		return hex_str;
	}

	namespace impl {
		template <typename RaIter, typename OutIter>
		void hash256_impl(RaIter first, RaIter last, OutIter first2, OutIter last2, int,
			std::random_access_iterator_tag) {
			hash256_one_by_one hasher;
			// hasher.init();
			hasher.process(first, last);
			hasher.finish();
			hasher.get_hash_bytes(first2, last2);
		}

		template <typename InputIter, typename OutIter>
		void hash256_impl(InputIter first, InputIter last, OutIter first2,
			OutIter last2, int buffer_size, std::input_iterator_tag) {
			std::vector<byte_t> buffer(buffer_size);
			hash256_one_by_one hasher;
			// hasher.init();
			while (first != last) {
				int size = buffer_size;
				for (int i = 0; i != buffer_size; ++i, ++first) {
					if (first == last) {
						size = i;
						break;
					}
					buffer[i] = *first;
				}
				hasher.process(buffer.begin(), buffer.begin() + size);
			}
			hasher.finish();
			hasher.get_hash_bytes(first2, last2);
		}
	}

	template <typename InIter, typename OutIter>
	void hash256(InIter first, InIter last, OutIter first2, OutIter last2,
		int buffer_size = NFSha256_BUFFER_SIZE_FOR_INPUT_ITERATOR) {
		NFSha256::impl::hash256_impl(
			first, last, first2, last2, buffer_size,
			typename std::iterator_traits<InIter>::iterator_category());
	}

	template <typename InIter, typename OutContainer>
	void hash256(InIter first, InIter last, OutContainer& dst) {
		hash256(first, last, dst.begin(), dst.end());
	}

	template <typename InContainer, typename OutIter>
	void hash256(const InContainer& src, OutIter first, OutIter last) {
		hash256(src.begin(), src.end(), first, last);
	}

	template <typename InContainer, typename OutContainer>
	void hash256(const InContainer& src, OutContainer& dst) {
		hash256(src.begin(), src.end(), dst.begin(), dst.end());
	}

	template <typename InIter>
	void hash256_hex_string(InIter first, InIter last, std::string& hex_str) {
		byte_t hashed[k_digest_size];
		hash256(first, last, hashed, hashed + k_digest_size);
		std::ostringstream oss;
		output_hex(hashed, hashed + k_digest_size, oss);
		hex_str.assign(oss.str());
	}

	template <typename InIter>
	std::string hash256_hex_string(InIter first, InIter last) {
		std::string hex_str;
		hash256_hex_string(first, last, hex_str);
		return hex_str;
	}

	inline void hash256_hex_string(const std::string& src, std::string& hex_str) {
		hash256_hex_string(src.begin(), src.end(), hex_str);
	}

	template <typename InContainer>
	void hash256_hex_string(const InContainer& src, std::string& hex_str) {
		hash256_hex_string(src.begin(), src.end(), hex_str);
	}

	template <typename InContainer>
	std::string hash256_hex_string(const InContainer& src) {
		return hash256_hex_string(src.begin(), src.end());
	}
	template<typename OutIter>void hash256(std::ifstream& f, OutIter first, OutIter last) {
		hash256(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>(), first, last);

	}
}// namespace NFSha256
